package cn.bloghut.lesson01;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @description 测试IP
 */
public class TestInetAddress {
    public static void main(String[] args) throws Exception {
        //查询本机的ip地址
        InetAddress localhost = InetAddress.getByName("localhost");
        // InetAddress localhost = InetAddress.getByName("127.0.0.1");
        // InetAddress localhost = InetAddress.getLocalHost();
        System.out.println(localhost);

        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);
        System.out.println("=================");
        //查询网站ip地址
        InetAddress name = InetAddress.getByName("www.baidu.com");
        System.out.println(name);
        System.out.println("=================");
        //常用方法
        //System.out.println(name.getAddress());
        System.out.println(name.getHostAddress());//获取主机ip地址
        System.out.println(name.getHostName());// 获取域名
        System.out.println(name.getCanonicalHostName());//获取规范的主机ip地址
    }
}

package cn.bloghut.lesson01;

import java.net.InetSocketAddress;

/**
 * @description TODO
 */
public class TesyInetSocketAddress {
    public static void main(String[] args) {

        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress socketAddress1 = new InetSocketAddress("localhost", 8080);

        // /127.0.0.1:8080
        System.out.println(socketAddress);
        // localhost/127.0.0.1:8080
        System.out.println(socketAddress1);
        System.out.println("====================");

        System.out.println(socketAddress.getAddress());//ip地址
        System.out.println(socketAddress.getHostName());//主机名称
        System.out.println(socketAddress.getHostString());
        System.out.println(socketAddress.getPort());//端口
        
    }
}

package cn.bloghut.lesson02;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @description 客户端
 */
public class TcpClientDemo1 {

    public static void main(String[] args) throws Exception{
        Socket socket = null;
        OutputStream os = null;
        //要知道服务器地址
        try {
            InetAddress serverIp = InetAddress.getByName("localhost");
            int port = 9999;
            //2.创建连接
            socket = new Socket(serverIp,port);
            //3.发生消息 IO流
            os = socket.getOutputStream();
            os.write("你好，世界".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (os != null) {
                os.close();
            }
            if (socket != null) {
                socket.close();
            }
        }
    }
}

package cn.bloghut.lesson02;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @description 服务器端
 */
public class TcpServerDemo01 {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = null;
        Socket accept = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1. 我得有一个地址
            serverSocket = new ServerSocket(9999);
            //2.等待客户端连接过来
            accept = serverSocket.accept();
            //3.读取客户端消息
            is = accept.getInputStream();

        /*byte[] buf = new byte[1024];
        int len;
        while ((len = is.read(buf)) != -1 ){
            String s = new String(buf, 0, len);
            System.out.println(s);
        }*/

            //管道流
            baos = new ByteArrayOutputStream();
            byte[] buff = new byte[1024];
            int len = -1;

            while ((len = is.read(buff)) != -1) {
                baos.write(buff, 0, len);
            }
            System.out.println(baos.toString());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (baos != null) {
                baos.close();
            }
            if (is != null) {
                is.close();
            }
            if (accept != null) {
                accept.close();
            }
            if (serverSocket != null) {
                serverSocket.close();
            }
        }
    }
}

package cn.bloghut.lesson02;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @description 服务端
 */
public class TcpServerDemo2 {
    public static void main(String[] args)  throws Exception{
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.监听客户端连接
        Socket accept = serverSocket.accept();
        //3.获取输入流
        InputStream is = accept.getInputStream();

        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));//接收文件就要用文件的管道流
        byte[] buff = new byte[1024];
        int len;
        while ((len = is.read(buff)) != -1){
            fos.write(buff,0,len);
        }

        //通过客户端我接收完毕了
        OutputStream os = accept.getOutputStream();
        os.write("我接收完毕了，你可以断开了".getBytes());

        fos.close();
        is.close();
        accept.close();
        serverSocket.close();
    }
}

package cn.bloghut.lesson02;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * @description 客户端
 */
public class TcpClientDemo2 {

    public static void main(String[] args) throws Exception {
        //1.建立连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();
        //3.读取文件
        FileInputStream is = new FileInputStream(new File("1.jpg"));
        byte[] buff = new byte[1024];
        int len;
        //4.写出文件
        while ((len = is.read(buff)) != -1) {
            os.write(buff, 0, len);
        }

        //通知服务器，我已经结束了
        socket.shutdownOutput();//我已经传输完了的意思

        //确定服务器接收完毕，才能够断开连接
        InputStream inputStream = socket.getInputStream();//接收字符、就用字节的管道流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] buff2 = new byte[1024];
        int len2;
        while ((len2 = inputStream.read(buff)) != -1) {
            bos.write(buff2, 0, len2);
        }
        System.out.println(bos.toString());

        //5.释放资源
        bos.close();
        inputStream.close();
        is.close();
        os.close();
        socket.close();
    }
}

package cn.bloghut.lesson3;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * @description 不需要连接服务器
 */
public class UdpClientDemo1 {
    public static void main(String[] args) throws Exception{

        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();
        //2.建个包
        String msg = "你好啊，服务器";
        //3.发送给谁
        InetAddress address = InetAddress.getByName("localhost");
        int port = 9090;

        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, address, port);
        //4.发送包
        socket.send(packet);
    }
}

package cn.bloghut.lesson3;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.ServerSocket;

/**
 * @description TODO
 */
public class UdpServerDemo1 {
    public static void main(String[] args) throws Exception{
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据包
        byte[] buff =new byte[1024];
        DatagramPacket packet = new DatagramPacket(buff, 0, buff.length);

        socket.receive(packet);//阻塞接收

        System.out.println(packet.getAddress());
        System.out.println(new String(packet.getData(),0,packet.getData().length));

        socket.close();
    }
}

package cn.bloghut.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

/**
 * @description 接收端
 */
public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {
        //获取连接
        DatagramSocket socket = new DatagramSocket(8080);
        while (true) {
            //准备数据
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket
                    (datas, 0,datas.length, new InetSocketAddress("localhost", 6666));
            //发送数据
            socket.send(packet);
            if (data.equals("bye")) {
                break;
            }
        }
        socket.close();
    }
}

package cn.bloghut.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * @description 接收端
 */
public class UdpReceiveDemo01 {

    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);
        while (true) {
            //准备接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);//阻塞式接收包裹


            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);

            //断开连接 bye
            if (receiveData.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

package com.awo.bio;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BIOServer {
    public static void main(String[] args) throws IOException {

        //线程池机制

        //思路
        //1. 创建一个线程池
        //2. 如果有客户端连接，就创建一个线程，与之通讯(单独写一个方法)

        //1. 创建一个线程池
        ExecutorService pool = Executors.newCachedThreadPool();

        //创建ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);

        System.out.println("服务器启动了");

        while (true) {

            //监听，等待客户端连接
            System.out.println("等待连接....");
            final Socket socket = serverSocket.accept();
            System.out.println("连接到一个客户端");

            //就创建一个线程，与之通讯(单独写一个方法)
            pool.execute(() -> {
                //可以和客户端通讯
                handler(socket);
            });
        }
    }

    //编写一个handler方法，和客户端通讯
    public static void handler(Socket socket) {
        InputStream is = null;
        try {
            System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
            byte[] bytes = new byte[1024];
            //通过socket 获取输入流
            is = socket.getInputStream();

            //循环的读取客户端发送的数据
            while (true) {
                System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
                System.out.println("read....");
                int read;
                if ((read = is.read(bytes)) != -1) {
                    //输出客户端发送的数据
                    System.out.println(new String(bytes, 0, read));
                } else {
                    break;
                }

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is == null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("关闭和client的连接");
            if (socket == null) {
                try {
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

public final Buffer flip() {
    // 将当前所在位置设置成缓存区的终点
    limit = position;
    // 将当前位置归0
    position = 0;
    mark = -1;
    return this;
}

public abstract class Buffer {
    //JDK1.4时，引入的api
    public final int capacity();//返回此缓冲区的容量(重要)
    public final int position();//返回此缓冲区的位置(重要)
    public final Buffer position (int newPosition);//设置此缓冲区的位置(重要)
    public final int limit();//返回此缓冲区的限制(重要)
    public final Buffer limit (int newLimit);//设置此缓冲区的限制(重要)
    
    public final Buffer mark();//在此缓冲区的位置设置标记
    public final Buffer reset();//将此缓冲区的位置重置为以前标记的位置
    
    public final Buffer clear();//清除此缓冲区, 即将各个标记恢复到初始状态，但是数据并没有真正擦除, 后面操作会覆盖(重要)
    public final Buffer flip();//反转此缓冲区(重要)
    
    public final Buffer rewind();//重绕此缓冲区
    public final int remaining();//返回当前位置与限制之间的元素数
    
    public final boolean hasRemaining();//告知在当前位置和限制之间是否有元素(重要)
    public abstract boolean isReadOnly();//告知此缓冲区是否为只读缓冲区(重要)

    //JDK1.6时引入的api
    public abstract boolean hasArray();//告知此缓冲区是否具有可访问的底层实现数组(重要)
    public abstract Object array();//返回此缓冲区的底层实现数组(重要)
    
    public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
    public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区
}

public abstract class ByteBuffer {
    //缓冲区创建相关api
    public static ByteBuffer allocateDirect(int capacity);//创建直接缓冲区(重要)
    public static ByteBuffer allocate(int capacity);//设置缓冲区的初始容量(重要)
    
    public static ByteBuffer wrap(byte[] array);//把一个数组放到缓冲区中使用
    //构造初始化位置offset和上界length的缓冲区
    public static ByteBuffer wrap(byte[] array,int offset, int length);
    
    //缓存区存取相关API
    public abstract byte get( );//从当前位置position上get，get之后，position会自动+1(重要)
    public abstract byte get (int index);//从绝对位置get(重要)
    //从当前位置上添加，put之后，position会自动+1(重要)
    public abstract ByteBuffer put (byte b);
    public abstract ByteBuffer put (int index, byte b);//从绝对位置上put(重要)
}

package com.awo.nio;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel01 {

    public static void main(String[] args) throws IOException {
        String str = "hello,world";
        //创建一个输出流->channel

        FileOutputStream fos = new FileOutputStream("D:\\编程\\netty\\src\\file01.txt");

        //通过 fileOutputStream 获取 对应的 FileChannel
        //这个 fileChannel 真实 类型是  FileChannelImpl
        FileChannel fileChannel = fos.getChannel();

        //创建一个缓冲区 ByteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        //将 str 放入 byteBuffer
        byteBuffer.put(str.getBytes());

        //对byteBuffer 进行flip
        byteBuffer.flip();

        //将byteBuffer 数据写入到 fileChannel
        fileChannel.write(byteBuffer);
        fos.close();
    }
}

package com.awo.nio;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel02 {
    public static void main(String[] args) throws IOException {

        //创建文件的输入流
        File file = new File("D:\\编程\\netty\\src\\file01.txt");
        FileInputStream fis = new FileInputStream(file);

        //通过fileInputStream 获取对应的FileChannel -> 实际类型  FileChannelImpl
        FileChannel channel = fis.getChannel();

        //创建缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());

        //将 通道的数据读入到Buffer
        channel.read(byteBuffer);

        //将byteBuffer 的 字节数据 转成String
        System.out.println(new String(byteBuffer.array()));
        fis.close();
    }
}

package com.awo.nio;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel03 {
    public static void main(String[] args) throws IOException {

        File file = new File("1.txt");
        FileInputStream fis = new FileInputStream(file);
        FileChannel readChannel = fis.getChannel();

        FileOutputStream fos = new FileOutputStream("2.txt");
        FileChannel writeChannel = fos.getChannel();

        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());

        //循环读取
        while (true) {

            //这里有一个重要的操作，一定不要忘了
            //清空buffer,其实就是复位一下属性值
            byteBuffer.clear();
            int read = readChannel.read(byteBuffer);
            //表示读完
            if (read == -1) {
                break;
            }
            //将buffer 中的数据写入到 fileChannel02 -- 2.txt
            byteBuffer.flip();
            writeChannel.write(byteBuffer);
        }

        //关闭相关的流
        fis.close();
        fos.close();
    }
}

public final Buffer clear() {
    position = 0;
    limit = capacity;
    mark = -1;
    return this;
}

package com.awo.nio;

import java.io.*;
import java.nio.channels.FileChannel;

public class NIOFileChannel04 {
    public static void main(String[] args) throws IOException {
        //创建相关流
        File file = new File("Koala.jpg");
        FileInputStream fis = new FileInputStream(file);
        FileOutputStream fos = new FileOutputStream("Koala01.jpg");

        //获取各个流对应的filechannel
        FileChannel sourceCh = fis.getChannel();
        FileChannel destCh = fos.getChannel();

        //使用transferForm完成拷贝
        destCh.transferFrom(sourceCh, 0, sourceCh.size());
        //关闭相关通道和流
        destCh.close();
        sourceCh.close();
        fos.close();
        fis.close();
    }
}

package com.awo.nio;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 说明：MappedByteBuffer 可让文件直接在内存(堆外内存)修改, 操作系统不需要拷贝一次
 */
public class MappedByteBufferTest {
    public static void main(String[] args) throws IOException {
        RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");
        //获取对应的通道
        FileChannel channel = randomAccessFile.getChannel();

        /**
         * 参数1: FileChannel.MapMode.READ_WRITE 使用的读写模式
         * 参数2： 0 ： 可以直接修改的起始位置
         * 参数3:  6: 是映射到内存的大小(不是索引位置) ,即将 1.txt 的多少个字节映射到内存
         * 可以直接修改的范围就是 0-6
         * 实际类型 DirectByteBuffer
         */
        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 6);

        mappedByteBuffer.put(0, (byte) 'H');
        mappedByteBuffer.put(5, (byte) '-');
        // 抛出异常：IndexOutOfBoundsException
        // mappedByteBuffer.put(6, (byte) '9');

        randomAccessFile.close();
        System.out.println("修改成功");
    }
}

package com.awo.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;

/**
 * Scattering：将数据写入到buffer时，可以采用buffer数组，依次写入  [分散读取]
 * Gathering: 从buffer读取数据时，可以采用buffer数组，依次读取 [聚集写入]
 */
public class ScatteringAndGatheringTest {
    public static void main(String[] args) throws IOException {
        //使用 ServerSocketChannel 和 SocketChannel 网络
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(7777);

        //绑定端口到socket ，并启动
        serverSocketChannel.socket().bind(inetSocketAddress);

        //创建buffer数组
        ByteBuffer[] byteBuffers = new ByteBuffer[2];
        byteBuffers[0] = ByteBuffer.allocate(5);
        byteBuffers[1] = ByteBuffer.allocate(3);

        //等客户端连接(telnet)
        SocketChannel socketChannel = serverSocketChannel.accept();
        //假定从客户端接收8个字节
        int messageLength = 8;

        //循环的读取
        while (true) {
            int byteRead = 0;
            while (byteRead < messageLength) {
                long read = socketChannel.read(byteBuffers);
                //累计读取的字节数
                byteRead += read;
                System.out.println("byteRead=" + byteRead);
                //使用流打印, 看看当前的这个buffer的position 和 limit
                Arrays.asList(byteBuffers).stream().map(buffer -> "position=" + buffer.position() + ", limit=" + buffer.limit())
                        .forEach(System.out::println);
            }
            //将所有的buffer进行flip
            Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());

            //将数据读出显示到客户端
            long byteWirte = 0;
            while (byteWirte < messageLength) {
                long write = socketChannel.write(byteBuffers);
                byteWirte += write;
            }

            //将所有的buffer 进行clear
            Arrays.asList(byteBuffers).forEach(buffer -> buffer.clear());
            System.out.println("byteRead:=" + byteRead + " byteWrite=" + byteWirte + ", messagelength" + messageLength);
        }

    }
}

public abstract class Selector implements Closeable { 
    //得到一个选择器对象
    public static Selector open();
    
    //监控所有注册的通道，当其中有 IO 操作可以进行时，将对应的 SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
    public int select(long timeout);
    
    //从内部集合中得到所有的 SelectionKey	
    public Set<SelectionKey> selectedKeys();
}

package com.awo.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NIOClient {
    public static void main(String[] args) throws IOException {
        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器端的ip 和 端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                System.out.println("因为连接需要时间，客户端不会阻塞，可以做其它工作..");
            }
        }
        //...如果连接成功，就发送数据
        String str = "hello, world";
        //Wraps a byte array into a buffer
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        //发送数据，将 buffer 数据写入 channel
        socketChannel.write(byteBuffer);
        System.in.read();
    }
}

public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;

public abstract class SelectionKey {
    public abstract Selector selector();//得到与之关联的 Selector 对象
    public abstract SelectableChannel channel();//得到与之关联的通道
    public final Object attachment();//得到与之关联的共享数据
    public abstract SelectionKey interestOps(int ops);//设置或改变监听事件
    public final boolean isAcceptable();//是否可以 accept
    public final boolean isReadable();//是否可以读
    public final boolean isWritable();//是否可以写
}

public abstract class ServerSocketChannel extends AbstractSelectableChannel  implements NetworkChannel{
    // 得到一个 ServerSocketChannel 通道(静态方法)
    public static ServerSocketChannel open();

    // 设置服务器端端口号
    public final ServerSocketChannel bind(SocketAddress local);

    // 设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
    public final SelectableChannel configureBlocking(boolean block);

    // 接受一个连接，返回代表这个连接的通道对象
    public SocketChannel accept();

    // 注册一个选择器并设置监听事件
    public final SelectionKey register(Selector sel, int ops);
}

public abstract class SocketChannel extends AbstractSelectableChannel implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, NetworkChannel{
    
    //得到一个 SocketChannel 通道
    public static SocketChannel open();
    
    //设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
    public final SelectableChannel configureBlocking(boolean block);
    
    //连接服务器
    public boolean connect(SocketAddress remote);
    
    //如果上面的方法连接失败，接下来就要通过该方法完成连接操作
    public boolean finishConnect();
    
    //往通道里写数据
    public int write(ByteBuffer src);
    
    //从通道里读数据
    public int read(ByteBuffer dst);
    
    //注册一个选择器并设置监听事件，最后一个参数可以设置共享数据
    public final SelectionKey register(Selector sel, int ops, Object att);
    
    //关闭通道
    public final void close();
}

package com.awo.nio.groupchat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class GroupChatServer {
    // 定义属性

    private ServerSocketChannel listenChannel;
    private Selector selector;
    private static final int PORT = 6667;

    // 构造器
    // 初始化工作
    public GroupChatServer() {
        try {
            // ServerSocketChannel
            listenChannel = ServerSocketChannel.open();
            // 得到选择器
            selector = Selector.open();
            // 绑定端口
            listenChannel.socket().bind(new InetSocketAddress(PORT));
            // 设置非阻塞模式
            listenChannel.configureBlocking(false);
            // 将该listenChannel 注册到selector
            listenChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 监听
     */
    public void listen() {
        System.out.println("监听线程: " + Thread.currentThread().getName());

        try {
            // 循环处理
            while (true) {
                int count = selector.select();
                // 有事件处理
                if (count > 0) {
                    // 得到SelectionKeys的迭代器
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        // 取出selectionkey
                        SelectionKey key = iterator.next();
                        // 监听到accept
                        if (key.isAcceptable()) {
                            // 得到socketChannel
                            SocketChannel socketChannel = listenChannel.accept();
                            // 设置非阻塞模式
                            socketChannel.configureBlocking(false);
                            // 将该 socketChannel 注册到 selector
                            socketChannel.register(selector, SelectionKey.OP_READ);
                            // 提示
                            System.out.println(socketChannel.getRemoteAddress() + " 上线 ");
                        }
                        // 通道发送read事件，即通道是可读的状态
                        if (key.isReadable()) {
                            // 调用readData处理读事件
                            readData(key);
                        }
                        // 当前的key 删除，防止重复处理
                        iterator.remove();
                    }
                } else {
                    System.out.println("等待....");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //发生异常处理....
        }
    }

    /**
     * 读取客户端消息
     * @param key
     */
    private void readData(SelectionKey key) {
        // 定义一个SocketChannel
        SocketChannel channel = null;

        try {
            // 取到关联的channel
            channel = (SocketChannel) key.channel();
            // 创建buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            // 从buffer读取数据到channel
            int count = channel.read(buffer);
            // 根据count的值做处理
            if (count > 0) {
                // 把缓存区的数据转成字符串
                String msg = new String(buffer.array());
                // 输出该消息
                System.out.println("form 客户端: " + msg);
                // 向其它的客户端转发消息(去掉自己), 专门写一个方法来处理
                sendInfoToOtherClients(msg, channel);
            }
        } catch (IOException e) {
            try {
                System.out.println(channel.getRemoteAddress() + " 离线了..");
                // 取消注册
                key.cancel();
            } catch (IOException ioException) {
                ioException.printStackTrace();
            } finally {
                // 关闭通道
                try {
                    channel.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }

    /**
     * 向其它的客户端转发消息(去掉自己)
     * @param msg 转发的消息
     * @param self 自己
     */
    private void sendInfoToOtherClients(String msg, SocketChannel self) {
        System.out.println("服务器转发消息中...");
        System.out.println("服务器转发数据给客户端线程: " + Thread.currentThread().getName());
        // 遍历 所有注册到selector 上的 SocketChannel,并排除 self
        for (SelectionKey key : selector.keys()) {
            //通过 key 取出对应的 SocketChannel
            Channel targetChannel = key.channel();

            //排除自己
            if (targetChannel instanceof SocketChannel && targetChannel != self) {
                try {
                    // 转型
                    SocketChannel dest = (SocketChannel) targetChannel;
                    // 将msg 存储到buffer
                    ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                    // 将buffer 的数据写入 通道
                    dest.write(buffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        //创建服务器对象
        GroupChatServer groupChatServer = new GroupChatServer();
        groupChatServer.listen();
    }
}

package com.awo.nio.groupchat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;

public class GroupChatClient {

    //定义相关的属性
    private static final String HOST = "127.0.0.1";
    private static final int PORT = 6667;
    private SocketChannel socketChannel;
    private Selector selector;
    private String username;

    //构造器, 完成初始化工作


    public GroupChatClient() {
        try {
            socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));
            socketChannel.configureBlocking(false);
            selector = Selector.open();
            socketChannel.register(selector, SelectionKey.OP_READ);
            username = socketChannel.getLocalAddress().toString().substring(1);
            System.out.println(username + " is ok...");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 向服务器发送消息
     *
     * @param info
     */
    public void sendInfo(String info) {
        info = username + " 说：" + info;
        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 读取从服务器端回复的消息
     */
    public void readInfo() {
        try {
            int readChannels = selector.select();
            // 有可以用的通道
            if (readChannels > 0) {
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        // 得到相关的通道
                        SocketChannel channel = (SocketChannel) key.channel();
                        // 得到一个Buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        // 读取
                        channel.read(buffer);
                        // 把读到的缓冲区的数据转成字符串
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                    // 删除当前的selectionKey, 防止重复操作
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        GroupChatClient groupChatClient = new GroupChatClient();
        // 启动一个线程, 每个3秒，读取从服务器发送数据
        new Thread(() -> {
            while (true) {
                groupChatClient.readInfo();
                try {
                    Thread.sleep(3000);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 发送数据给服务器端
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            groupChatClient.sendInfo(s);
        }
    }
}

File file = new File("test.txt");
RandomAccessFile raf = new RandomAccessFile(file, "rw");

byte[] arr = new byte[(int) file.length()];
raf.read(arr);

Socket socket = new ServerSocket(8080).accept();
socket.getOutputStream().write(arr);

import java.io.DataInputStream;
import java.net.ServerSocket;
import java.net.Socket;

//java IO 的服务器
public class OldIOServer {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(7001);

        while (true) {
            Socket socket = serverSocket.accept();
            DataInputStream dataInputStream = new DataInputStream(socket.getInputStream());

            try {
                byte[] byteArray = new byte[4096];

                while (true) {
                    int readCount = dataInputStream.read(byteArray, 0, byteArray.length);

                    if (-1 == readCount) {
                        break;
                    }
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
}

import java.io.DataInputStream;
import java.net.ServerSocket;
import java.net.Socket;

//java IO 的服务器
public class OldIOServer {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(7001);

        while (true) {
            Socket socket = serverSocket.accept();
            DataInputStream dataInputStream = new DataInputStream(socket.getInputStream());

            try {
                byte[] byteArray = new byte[4096];

                while (true) {
                    int readCount = dataInputStream.read(byteArray, 0, byteArray.length);

                    if (-1 == readCount) {
                        break;
                    }
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
}

import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

//服务器
public class NewIOServer {
    public static void main(String[] args) throws Exception {

        InetSocketAddress address = new InetSocketAddress(7001);

        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        ServerSocket serverSocket = serverSocketChannel.socket();

        serverSocket.bind(address);

        //创建buffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(4096);

        while (true) {
            SocketChannel socketChannel = serverSocketChannel.accept();

            int readcount = 0;
            while (-1 != readcount) {
                try {

                    readcount = socketChannel.read(byteBuffer);

                }catch (Exception ex) {
                   // ex.printStackTrace();
                    break;
                }
                //
                byteBuffer.rewind(); //倒带 position = 0 mark 作废
            }
        }
    }
}